Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume8/hier

Internet Message Format | 1987-02-11 | 29.8 KB

Subject:  v08i057:  Directory hiearchy scanner
Newsgroups: mod.sources
Approved: mirror!rs

Submitted by: Alan Silverstein <seismo!hplabs!hpfcla!hpfcdt!ajs>
Mod.sources: Volume 8, Issue 57
Archive-name: hier

hier(1) is yet another way to view a directory hierarchy.  It's
analogous to ls -R, but presents the data in a new fashion especially
useful for novice users or display on a wall.  Now, with the plethora of
similar tools available, what's special about this one?

- I wrote it after four *years* of consideration and using similar tools.
- I interacted with an "end user" who knew what he wanted.
- The code is carefully crafted, commented, and tested.  (But not yet
  widely ported, I fear.)

So give it a try, and see if you like it.

Also note!  This package includes a "sorted ftw()", which is a major
and non-trivial library routine you'll love if you are familiar with
ftw(3) (file tree walk), but wish you could get sorted results.

Alan Silverstein, Hewlett-Packard Systems Software Operation, Fort Collins,
Colorado; {ihnp4 | hplabs}!hpfcla!ajs; 303-229-3053; (lat-long on request :-)

[  I ported SFTW to BSD.  This included writing (most of?) <ftw.h>
   and a couple of real minor tweaks.  I started on HIER, but gave up
   at the first bug.  A public-domain manpage for sftw would be real
   nice.  -r$ ]

#! /bin/sh
# This is a shell archive.  Remove anything before this line,
# then unpack it by saving it in a file and typing "sh file".
# If all goes well, you will see the message "End of shell archive."
# Contents:  Makefile Makefile.bsd ftw.h hier.1 hier.c sftw.c
PATH=/bin:/usr/bin:/usr/ucb; export PATH
echo shar: extracting "'Makefile'" '(324 characters)'
if test -f 'Makefile' ; then
  echo shar: will not over-write existing file "'Makefile'"
else
sed 's/^X//' >Makefile <<'@//E*O*F Makefile//'
X# Makefile for hier(1), needed to link with sftw().
X
Xhier: hier.c sftw.o
X    cc -v -O -s -o hier hier.c sftw.o
X
Xsftw.o: sftw.c
X    cc -v -O -c sftw.c
X
Xdebug: hier.c sftw.c
X    cc -v -g -o hier hier.c sftw.c
X    rm -f hier.o sftw.o    # since they're useless.
X
Xtest: sftw.c
X    cc -v -O -o sftw sftw.c -DTEST
X
Xclean:
X    rm -f *.o hier sftw core
@//E*O*F Makefile//
if test 324 -ne "`wc -c <'Makefile'`"; then
    echo shar: error transmitting "'Makefile'" '(should have been 324 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'Makefile.bsd'" '(298 characters)'
if test -f 'Makefile.bsd' ; then
  echo shar: will not over-write existing file "'Makefile.bsd'"
else
sed 's/^X//' >Makefile.bsd <<'@//E*O*F Makefile.bsd//'
X# Makefile for hier(1), needed to link with sftw().
X# This is for BSD sites.  mirror!rs
X
XCFLAGS = -O -DBSD -I. -Dstrrchr=rindex
XGETOPT=-lgetopt
X
Xhier: hier.c sftw.o
X    cc $(CFLAGS) -s -o hier hier.c sftw.o $(GETOPT)
X
Xtest: sftw.c
X    cc $(CFLAGS) -DTEST -o sftw sftw.c
X
Xclean:
X    rm -f *.o hier sftw core
@//E*O*F Makefile.bsd//
if test 298 -ne "`wc -c <'Makefile.bsd'`"; then
    echo shar: error transmitting "'Makefile.bsd'" '(should have been 298 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'ftw.h'" '(576 characters)'
if test -f 'ftw.h' ; then
  echo shar: will not over-write existing file "'ftw.h'"
else
sed 's/^X//' >ftw.h <<'@//E*O*F ftw.h//'
X/*
X**  This is a version of <ftw.h> for sites that don't have it.  I just
X**  picked four values at random for the #define's that sftw needed; I
X**  doubt that this is binary-compatible with AT&T's <ftw.h>, and this
X**  may well be missing something.  Oh, well, it's public-domain...
X**    -Rich $alz, mirror!rs
X*/
X
X
X/*
X**  These values are passed on to the user's function, as the third
X**  parameter.
X*/
X#define    FTW_F        1    /* A file                */
X#define    FTW_D        2    /* A directory                */
X#define    FTW_DNR        3    /* A directory that couldn't be read    */
X#define    FTW_NS        4    /* A stat() failure            */
@//E*O*F ftw.h//
if test 576 -ne "`wc -c <'ftw.h'`"; then
    echo shar: error transmitting "'ftw.h'" '(should have been 576 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'hier.1'" '(1732 characters)'
if test -f 'hier.1' ; then
  echo shar: will not over-write existing file "'hier.1'"
else
sed 's/^X//' >hier.1 <<'@//E*O*F hier.1//'
X.TH HIER 1 "Unsupported Utility"
X.SH NAME
Xhier \- show filesystem hierarchy
X.SH SYNOPSIS
X.B hier
X[
X.B \-adp
X] [
X.BI \-c \0columns
X] [
X.BI \-i \0indent
X]
X.br
X[
X.I directories...
X]
X.ad b
X.SH DESCRIPTION
XThis command shows you a filesystem hierarchy in a useful, indented way.
XAt each level files are sorted in two groups:
Xnon-directory files,
Xthen directories (recursing into each one).
XIt examines the named
X.IR directories ,
Xor by default the present working directory.
X.PP
XOptions are:
X.TP
X.B \-a
XAll: include directories and files whose names start with ".".
X.TP
X.B \-d
XShow directories only; skip other types of files.
X.TP
X.B \-p
XPrint filenames packed onto lines, not aligned in columns.
X.TP
X.B \-c
XSet width of display for showing multiple filenames on a line
X(or use the COLUMNS environment variable).
XThe default is 80 columns.
X.TP
X.B \-i
XSet indentation (number of blanks) per hierarchy level.
XThe default is 4 spaces per level.
X.SH EXAMPLES
X.TP
Xhier
X.br
XShow all non-"." files, recursively,
Xin and under the current directory.
X.TP
Xhier -apc 40 /etc
XShow all directories and files,
Xincluding any whose filenames start with ".",
Xin a format 40 columns wide,
Xand with filenames packed into lines,
Xunder directory "/etc".
X.SH SEE ALSO
Xls(1), sftw(3) (does not exist (yet))
X.SH DIAGNOSTICS
XIf a file is not stat-able,
Xor a directory is not readable,
Xthe filename is printed on a line to itself,
Xlike a directory (sorted with directory names),
Xwith an appropriate message following.
X.SH BUGS
XUnlike
X.IR ls (1),
Xit sorts files across lines rather than down columns.
XFixing this would be non-trivial.
X.PP
XAlso, due to the behavior of
X.IR sftw (3)
X(like
X.IR ftw (3)),
Xit never lists "." and ".." files, even with the
X.B \-a
Xoption.
@//E*O*F hier.1//
if test 1732 -ne "`wc -c <'hier.1'`"; then
    echo shar: error transmitting "'hier.1'" '(should have been 1732 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'hier.c'" '(8409 characters)'
if test -f 'hier.c' ; then
  echo shar: will not over-write existing file "'hier.c'"
else
sed 's/^X//' >hier.c <<'@//E*O*F hier.c//'
X/*
X * Show file system hierarchy.
X *
X * Usage: see below.
X *
X * Unlike ls(1), it sorts files across lines rather than down columns.
X * Fixing this would be non-trivial, involving saving filenames until it
X * was time to dump them.
X *
X * Also, due to the behavior of sftw() (like ftw()), it never lists "." and
X * ".." files.
X *
X * Warning:  If you use ftw() instead of sftw(), -a option will stop working.
X *
X * Warning:  If you use ftw() instead of sftw(), a bug will appear.  This is
X * because two calls in a row from ftw() to OneFile() may be made for ordinary
X * files, where the second is in a directory a level above the first one.
X * OneFile() would have to check to see if each ordinary file's path is
X * different than the previous one's, indicating a change of directory level.
X */
X
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <stdio.h>
X#include <ftw.h>
X#ifdef    BSD
X#include <sys/dir.h>            /* for DIRSIZ */
X#include <strings.h>
X#else
X#include <sys/ndir.h>            /* for DIRSIZ */
X#include <string.h>
X#endif    /* BSD */
X
X
X/*********************************************************************
X * MISCELLANEOUS GLOBAL VALUES:
X */
X
X#define    PROC                /* null; easy to find procs */
X#define    FALSE    0
X#define    TRUE    1
X#define    CHNULL    ('\0')
X#define    CPNULL    ((char *) NULL)
X#define    REG    register
X
Xchar *usage[] = {
X    "usage: %s [-adp] [-c columns] [-i indent] [directories...]",
X    "-a include directories and files whose names start with \".\"",
X    "-d show directories only",
X    "-p print filenames packed onto lines, not aligned",
X    "-c set width of display (or use COLUMNS env variable; default = 80)",
X    "-i set indentation per level; default = 4",
X    "Does current directory by default.",
X    CPNULL,
X};
X
Xchar    *myname;            /* how program was invoked    */
Xint    aflag    = FALSE;        /* -a (all files) option    */
Xint    dflag    = FALSE;        /* -d (directories) option    */
Xint    pflag    = FALSE;        /* -p (packed filenames) option    */
Xint    columns    = 0;            /* from -c option or env    */
Xint    indent    = 0;            /* from -i option or default    */
X
X#define    COLUMNS    80            /* width of display        */
X#define    INDENT     4            /* per directory level        */
X
Xint    startlen;            /* of current arg (filename)    */
Xint    nextcol = 0;            /* column in output line    */
X
X
X/************************************************************************
X * M A I N
X *
X * Initialize, then call sftw() for each given filename after clearing
X * global startlen to indicate a new starting file.  When done, if global
X * nextcol != 0 (in the middle of an output line), finish the last line.
X */
X
XPROC main (argc, argv)
X    int    argc;
X    char    **argv;
X{
Xextern    int    optind;            /* from getopt()    */
Xextern    char    *optarg;        /* from getopt()    */
XREG    int    option;            /* option "letter"    */
X    char    *argdef = ".";        /* default argument    */
X    char    *colstr;        /* from environment    */
X
X    char    *getenv();
X    int    OneFile();
X
X/* #define DEPTH (_NFILE - 5)        /* for ftw(), but not sftw() */
X
X/*
X * PARSE ARGUMENTS:
X */
X
X    myname = *argv;
X
X    while ((option = getopt (argc, argv, "adpc:i:")) != EOF)
X    {
X        switch (option)
X        {
X        case 'a':    aflag    = TRUE;            break;
X        case 'd':    dflag    = TRUE;            break;
X        case 'p':    pflag    = TRUE;            break;
X        case 'c':    columns    = atoi (optarg);    break;
X        case 'i':    indent    = atoi (optarg);    break;
X        default:    Usage();
X        }
X    }
X
X    if (dflag && pflag)
X        Error ("-d and -p don't make sense together");
X
X/*
X * FINISH INITIALIZING:
X */
X
X    if ((columns == 0)                /* no value given */
X     && (((colstr = getenv ("COLUMNS")) == CPNULL)    /* undefined      */
X      || ((columns = atoi (colstr)) == 0)))      /* defined null or zero */
X    {
X        columns = COLUMNS;        /* use default */
X    }
X
X    if (indent == 0)        /* no value given */
X        indent = INDENT;        /* use default      */
X
X    argc -= optind;            /* skip options    */
X    argv += optind;
X
X    if (argc == 0)            /* no filenames given */
X    {
X        argc = 1;
X        argv = & argdef;        /* use default */
X    }
X
X/*
X * WALK EACH FILE TREE:
X */
X
X    while (argc-- > 0)
X    {
X        startlen = 0;
X
X        if (sftw (*argv, OneFile, aflag))
X        Error ("file tree walk failed for file \"%s\"", *argv);
X
X        argv++;
X    }
X
X    if (nextcol)            /* last line not finished */
X        putchar ('\n');
X
X    exit (0);
X
X} /* main */
X
X
X/************************************************************************
X * O N E   F I L E
X *
X * Called from sftw() to handle (print) one file, given a filename (starting
X * file plus sub-file part) and ftw() file type.  Always returns zero (all
X * is well, keep going).
X *
X * It's messy because of the need to print multiple non-directory basenames
X * on one line.  Uses global startlen to save time figuring depth beyond
X * starting file.  If currently zero, this is the starting file; print the
X * fullname, on a line alone, with no indent.
X *
X * Use globals startlen, indent, columns, and nextcol.
X */
X
XPROC int OneFile (filename, statp, type)
X    char    *filename;    /* name        */
X    struct    stat *statp;    /* info, unused    */
X    int    type;        /* ftw() type    */
X{
XREG    char    *basename;    /* part of filename */
X
X/*
X * PRINTING FORMATS (matching ftw() types):
X */
X
Xstatic    char    *FMT_D   = "%s/\n";
Xstatic    char    *FMT_DNR = "%s/ (not readable)\n";
Xstatic    char    *FMT_NS  = "%s (not stat'able)\n";
Xstatic    char    *FMT_F1     = "%s\n";        /* for starting file */
Xstatic    char    *FMT_F2     = "%-*s";        /* for sub-file         */
X
X#ifdef    BSD
X#define    FILEWIDTH MAXNAMLEN            /* for FMT_F2 */
X#else
X#define    FILEWIDTH (DIRSIZ + 1)            /* for FMT_F2 */
X#endif    /* BSD */
XREG    int    filewidth = FILEWIDTH;        /* if ! pflag */
X
X#define    NEWLINE     { putchar ('\n'); nextcol = 0; }  /* for speed and clarity */
X
X/*
X * OPTIONALLY IGNORE NON-DIRECTORY (even if named as an input argument):
X */
X
X    if (dflag && (type == FTW_F))
X        return (0);
X
X/*
X * HANDLE STARTING FILE:
X */
X
X    if (startlen == 0)
X    {
X        startlen = strlen (filename);    /* set for later */
X
X        if (nextcol)        /* end previous line */
X        NEWLINE;        /* sets nextcol == 0 */
X
X        printf ((type == FTW_D)   ? FMT_D    :
X            (type == FTW_DNR) ? FMT_DNR    :
X            (type == FTW_NS)  ? FMT_NS    : FMT_F1, filename);
X
X        return (0);
X    }
X
X/*
X * SET BASENAME FOR ALL OTHER TYPES:
X */
X
X    basename = ((basename = strrchr (filename, '/')) == CPNULL) ?
X           filename : (basename + 1);    /* past "/" if any */
X
X/*
X * HANDLE NON-DIRECTORY SUB-FILE (print multiple per line):
X */
X
X    if (type == FTW_F)
X    {
X        if (pflag)                /* else use preset value */
X        filewidth = strlen (basename) + 1;
X
X        if (nextcol    && (nextcol + filewidth >= columns))    /* overflow */
X        NEWLINE;            /* sets nextcol == 0 */
X
X        if (nextcol == 0)        /* start new line with indent */
X        nextcol = PrintIndent (filename);
X
X        printf (FMT_F2, filewidth, basename);
X        nextcol += filewidth;
X        return (0);
X    }
X
X/*
X * HANDLE DIRECTORY OR OTHER SUB-FILE (print on line by itself):
X */
X
X    if (nextcol)            /* end previous line */
X        NEWLINE;            /* sets nextcol == 0 */
X
X    PrintIndent (filename);
X
X    printf ((type == FTW_D)   ? FMT_D   :
X        (type == FTW_DNR) ? FMT_DNR : FMT_NS, basename);
X
X    return (0);
X
X} /* OneFile */
X
X
X/************************************************************************
X * P R I N T   I N D E N T
X *
X * Given a filename and globals startlen and indent, print the total
X * indentation needed before the name, which is indent times the number of
X * slashes past startlen (which should be >= 1).  Return the indent value.
X */
X
XPROC int PrintIndent (filename)
XREG    char    *filename;
X{
XREG    int    depth = 0;
XREG    int    totind;
X    int    retval;
X
X    filename += startlen;        /* start of sub-part */
X
X    while (*filename != CHNULL)
X        if (*filename++ == '/')
X        depth++;
X
X    retval = totind = indent * depth;
X
X    while (totind-- > 0)
X        putchar (' ');
X
X    return (retval);
X
X} /* PrintIndent */
X
X
X/************************************************************************
X * U S A G E
X *
X * Print usage messages (char *usage[]) to stderr and exit nonzero.
X * Each message is followed by a newline.
X */
X
XPROC Usage()
X{
XREG    int    which = 0;        /* current line */
X
X    while (usage [which] != CPNULL)
X    {
X        fprintf (stderr, usage [which++], myname);
X        putc ('\n', stderr);
X    }
X
X    exit (1);
X
X} /* Usage */
X
X
X/************************************************************************
X * E R R O R
X *
X * Print an error message to stderr and exit nonzero.  Message is preceded
X * by "<myname>: " using global char *myname, and followed by a newline.
X */
X
X/* VARARGS */
XPROC Error (message, arg1, arg2, arg3, arg4)
X    char    *message;
X    long    arg1, arg2, arg3, arg4;
X{
X    fprintf (stderr, "%s: ", myname);
X    fprintf (stderr, message, arg1, arg2, arg3, arg4);
X    putc ('\n', stderr);
X
X    exit (1);
X
X} /* Error */
@//E*O*F hier.c//
if test 8409 -ne "`wc -c <'hier.c'`"; then
    echo shar: error transmitting "'hier.c'" '(should have been 8409 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'sftw.c'" '(14313 characters)'
if test -f 'sftw.c' ; then
  echo shar: will not over-write existing file "'sftw.c'"
else
sed 's/^X//' >sftw.c <<'@//E*O*F sftw.c//'
X/*
X * Sorted file tree walk (library routine).
X *
X * Identical (in theory) to ftw(3), except:
X *
X * - Calls user's fn() with the files sorted alphabetically (per strcmp(3))
X *   in two groups:  All non-directories first, followed by directories (with
X *   the descendents of each directory after the directory).  Non-stat'able
X *   files and non-readable directories are included in the second group.
X *
X * - Doesn't keep one file open for each level of recursion, so it doesn't
X *   need a depth argument (which actually affects file opens/closes, NOT
X *   maximum search depth).
X *
X * - Uses a lot more malloc space.
X *
X * - Supports an additional argument which tells it to include all files
X *   and directories, including those whose names start with "." (except that
X *   the given filename is always included, regardless of the flag, like
X *   ls(1)).  The caller could implement this, but not very efficiently.
X *
X * Like ftw(), it ignores "." and ".." files, even with the all flag.
X *
X * For convenience, form of call is:
X *
X *    #include <ftw.h>
X *
X *    int sftw (path, fn, allfiles)
X *        char    *path;
X *        int    (*fn)();
X *        int    allfiles;
X *
X * Form of fn() is:
X *
X *    int fn (name, statp, type)
X *        char    *name;
X *        struct    stat *statp;
X *        int    type;
X *
X * See ftw(3) for more information.
X *
X * Compile with -DTEST to get a runnable test version that walks from "."
X * and tells types, permissions, and filenames passed to fn().
X */
X
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <ftw.h>
X#ifdef    BSD
X#include <sys/dir.h>
X#else
X#include <ndir.h>
X#endif    /* BSD */
X
Xstatic char *malloc(), *strcpy();
Xstatic void free();
X
X
X/*********************************************************************
X * MISCELLANEOUS GLOBAL VALUES:
X */
X
X#define    PROC                /* null; easy to find procs */
X#define    FALSE    0
X#define    TRUE    1
X#define    CHNULL    ('\0')
X#define    CPNULL    ((char *) NULL)
X#define    REG    register
X
X/* built-up filename for passing to the user program; hope it's big enough */
Xstatic    char filename [1000];
X
Xstatic    unsigned short euid, egid;    /* only get them once */
X
X
X
X/************************************************************************
X * FILE DATA STRUCTURE:
X *
X * A contiguous array of pointers is used for sorting, built after knowing
X * how many directory entries there are to sort.  Each entry points to a
X * struct filedata which holds information for one directory entry.
X */
X
Xtypedef    struct filedata *fdpt;
Xtypedef    struct filedata **fdppt;
X
Xstruct filedata {
X    char    *name;        /* in malloc'd space    */
X    int    type;        /* see ftw.h        */
X    struct    stat statbuf;    /* from stat(2)        */
X};
X
X
X/************************************************************************
X * FILE AND STRING DATA BLOCKS:
X *
X * Since a directory may grow arbitrarily as it's read, there's no way to
X * know in advance how big it is.  And it's necessary to return all malloc'd
X * memory.  To make this possible, and to save malloc space and time, directory
X * entry data and filenames are stored in buffers allocated a chunk a time.
X */
X
X#define    DBENTRIES    20    /* file entries per datablock */
X#define    STRINGENTRIES 1008    /* chars per string buffer    */
X
Xtypedef    struct datablock *dbpt;
Xtypedef    struct datablock **dbppt;
X
Xstruct datablock {
X    dbpt    next;                /* next block if any */
X    struct    filedata fd [DBENTRIES];    /* the data itself   */
X};
X
X#define    DBNULL  ((dbpt) NULL)
X#define    DBSIZE  (sizeof (struct datablock))
X
X
Xtypedef struct stringblock *sbpt;
Xtypedef struct stringblock **sbppt;
X
Xstruct stringblock {
X    sbpt    next;                /* next block if any */
X    char    buf [STRINGENTRIES];        /* the data itself   */
X};
X
X#define    SBNULL  ((sbpt) NULL)
X#define    SBSIZE  (sizeof (struct stringblock))
X
X
X/************************************************************************
X * S F T W
X *
X * Handle the filename given by the user.  Since sftw() must stat() each
X * file before sorting, the first (top level) file must be handled specially,
X * not as part of re-entrant code.  (Think about it...)
X */
X
XPROC int sftw (path, UserFunc, allfiles)
X    char    *path;
X    int    (*UserFunc)();
X    int    allfiles;
X{
X    struct    stat statbuf;        /* from first file    */
X    int    type;            /* of first file    */
X    int    retval;            /* return by UserFunc()    */
X    unsigned short geteuid(), getegid();
X
X    euid = geteuid();    /* initialize values */
X    egid = getegid();
X
X/*
X * HANDLE INITIAL FILE:
X */
X
X    type = GetType (path, & statbuf);
X
X    if (retval = UserFunc (path, & statbuf, type))    /* it's unhappy */
X        return (retval);
X
X    if (type != FTW_D)            /* we're done */
X        return (0);
X
X/*
X * WORK ON A READABLE DIRECTORY:
X */
X
X    strcpy (filename, path);        /* now we can append to it */
X    strcat (filename, "/");            /* prepare for additions   */
X
X    return (DoDirectory (UserFunc, allfiles));
X
X} /* sftw */
X
X
X/************************************************************************
X * D O   D I R E C T O R Y
X *
X * Given UserFunc(), all files flag, and global filename (directory path) where
X * to start and on which to build complete pathnames, read the directory, sort
X * filenames, and call UserFunc() for each file in the directory.  This routine
X * calls itself to recurse, after each directory name is passed to UserFunc().
X * Because it reads and saves a directory's contents in order to sort them, it
X * does not keep any files open while recursing, just lots of memory.
X *
X * Free all memory from this level before returning, even in case of error.
X * Return -1 in case of error, or the value from UserFunc() if non-zero.
X */
X
XPROC static int DoDirectory (UserFunc, allfiles)
X    int    (*UserFunc)();
X    int    allfiles;        /* include ".*" files?      */
X{
X    dbpt    dbhead = DBNULL;    /* first datablock ptr      */
X    sbpt    sbhead = SBNULL;    /* first stringblock ptr  */
X
X    fdppt    fdphead;        /* filedata list to sort  */
XREG    fdppt    fdpcurr;        /* current list pointer      */
XREG    fdpt    fdcurr;            /* current entry pointer  */
XREG    int    files;            /* number in directory      */
X
X    int    retval;            /* copy of return value      */
X
X/* pointer into filename where to append basenames */
XREG    char    *basename = filename + strlen (filename);
X
X    int    FDCmp();
X    void    qsort();
X
X#define    RETURN(value) { FreeBlocks (dbhead, sbhead); return (value); }
X
X/*
X * READ DIRECTORY:
X */
X
X    if ((files = ReadDirectory (& dbhead, & sbhead, allfiles)) < 0)
X        RETURN (-1);
X
X/*
X * BUILD AND SORT POINTERS TO FILES:
X *
X * Get a big chunk of contiguous memory for the pointers, then set them up.
X * Afterwards, filedata entries will be accessed via the pointers.
X */
X
X    if ((fdphead = (fdppt) malloc (files * sizeof (fdpt))) == (fdppt) NULL)
X        RETURN (-1);
X
X#undef    RETURN
X#define    RETURN(value) { FreeBlocks (dbhead, sbhead); \
X            free ((char *) fdphead); return (value); }
X
X    SetFDList (fdphead, fdphead + files, dbhead);
X    qsort ((char *) fdphead, (unsigned) files, sizeof (fdpt), FDCmp);
X
X/*
X * TRAVERSE FILES USING SORTED POINTERS:
X *
X * Append each file's basename to the current path in global filename,
X * overlaying whatever basename was there before, and pass it to UserFunc().
X */
X
X    fdpcurr = fdphead;
X
X    while (files-- > 0)
X    {
X        strcpy (basename, (fdcurr = (*fdpcurr++)) -> name);
X
X        if (retval = UserFunc (filename, & (fdcurr -> statbuf),
X                   fdcurr -> type))  /* it's unhappy */
X        {
X        RETURN (retval);
X        }
X
X/*
X * RECURSE FOR A DIRECTORY:
X */
X
X        if ((fdcurr -> type) == FTW_D)
X        {
X        strcat (basename, "/");        /* for next level */
X
X        if (retval = DoDirectory (UserFunc, allfiles))
X            RETURN (retval);
X        }
X    }
X
X    RETURN (0);
X
X} /* DoDirectory */
X
X
X/************************************************************************
X * R E A D   D I R E C T O R Y
X *
X * Given pointers to datablock and stringblock chain head pointers, all files
X * flag, and global filename (name of a readable directory) on which to build
X * complete pathnames, open, read, and close a directory, saving name, stat,
X * and type information on each file in a chain of datablocks and stringblocks,
X * and setting the chain head pointers.  Return the number of filenames read
X * and saved (>= 0), or -1 in case of error, but always close the directory.
X */
X
XPROC static int ReadDirectory (dbheadp, sbheadp, allfiles)
X    dbppt    dbheadp;        /* start of chain    */
X    sbppt    sbheadp;        /* start of chain    */
X    int    allfiles;        /* include ".*" files?    */
X{
XREG    DIR    *dirp;            /* for reading directory  */
XREG    struct    direct *entp;        /* directory entry      */
XREG    char    *name;            /* fast copy of filename  */
X
XREG    dbpt    dbcurr;            /* current datablock ptr  */
X    dbppt    dbnextp = dbheadp;    /* next datablock ptr ptr */
XREG    int    dbentry = DBENTRIES;    /* current entry in block */
X
XREG    fdpt    fdcurr;            /* current filedata entry */
X
XREG    sbpt    sbcurr;            /* current stringblock ptr  */
X    sbppt    sbnextp = sbheadp;    /* next stringblock ptr ptr */
XREG    char    *end   = "";        /* last + 1 of block        */
XREG    char    *start = end;        /* next free place        */
X
X/* pointer into filename where to append basenames */
XREG    char    *basename = filename + strlen (filename);
XREG    int    files      = 0;        /* files read and saved      */
X
X#undef    RETURN
X#define    RETURN(value) { closedir (dirp); return (value); }
X
X/*
X * OPEN AND READ DIRECTORY:
X */
X
X    if ((dirp = opendir (filename)) == (DIR *) NULL)
X        return (-1);        /* hope errno is set */
X
X    /* now be sure to use the RETURN() macro */
X
X    while ((entp = readdir (dirp)) != (struct direct *) NULL)
X    {
X
X/*
X * OPTIONALLY SKIP ".*" FILES:
X *
X * Always skip "." and ".." files, like ftw().
X */
X
X        if ((* (name = entp -> d_name) == '.')    /* fast check */
X         && ((! allfiles)
X          ||  (name [1] == CHNULL)
X          || ((name [1] == '.') && (name [2] == CHNULL))))
X        {
X        continue;
X        }
X
X        files++;
X
X/*
X * GET A NEW DATABLOCK; APPEND TO CHAIN:
X */
X
X        if (dbentry >= DBENTRIES)        /* block is full */
X        {
X        if ((dbcurr = *dbnextp = (dbpt) malloc (DBSIZE)) == DBNULL)
X            RETURN (-1);
X
X        * (dbnextp = & (dbcurr -> next)) = DBNULL;
X        dbentry = 0;
X        }
X
X/*
X * GET A NEW STRINGBLOCK; APPEND TO CHAIN:
X *
X * Yes, we may abandon some unused space in the previous block...  Hope that
X * STRINGENTRIES is much larger than the average directory entry name size.
X */
X
X        if ((entp -> d_namlen) + 1 > (end - start))
X        {
X        if ((sbcurr = *sbnextp = (sbpt) malloc (SBSIZE)) == SBNULL)
X            RETURN (-1);
X
X        * (sbnextp = & (sbcurr -> next)) = SBNULL;
X        end = (start = (sbcurr -> buf)) + STRINGENTRIES;
X        }
X
X/*
X * SAVE INFORMATION ON ONE FILE:
X *
X * Append each file's basename to the current path in global filename,
X * overlaying whatever basename was there before, and pass it to GetType().
X */
X
X        fdcurr = (dbcurr -> fd) + (dbentry++);    /* quick pointer */
X
X        strcpy (((fdcurr -> name) = start), name);
X        start += (entp -> d_namlen) + 1;
X
X        strcpy (basename, name);
X        (fdcurr -> type) = GetType (filename, & (fdcurr -> statbuf));
X
X    } /* while */
X
X    RETURN (files);
X
X} /* ReadDirectory */
X
X
X/************************************************************************
X * G E T   T Y P E
X *
X * Given a filename and a pointer to a stat structure, stat() the file into the
X * structure and return an appropriate ftw() type.  Since directories are not
X * opened for reading until much later, after sorting, determine readability
X * now using euid, egid, and st_mode.  Can't use access(2) because it checks
X * real ids, not effective (sigh).
X */
X
XPROC static int GetType (name, statp)
X    char    *name;
X    struct    stat *statp;
X{
X#define    UREAD (S_IREAD)         /* read permission bits for user, group, other */
X#define    GREAD (S_IREAD >> 3)
X#define    OREAD (S_IREAD >> 6)
X
X    if (stat (name, statp) < 0)
X        return (FTW_NS);            /* not stat'able */
X
X    if (((statp -> st_mode) & S_IFMT) != S_IFDIR)
X        return (FTW_F);            /* not directory */
X
X    /* pick appropriate permission bit, then see if it's set */
X
X    return (
X        ( ((statp -> st_uid) == euid) ? ((statp -> st_mode) & UREAD) :
X          ((statp -> st_gid) == egid) ? ((statp -> st_mode) & GREAD) :
X                        ((statp -> st_mode) & OREAD) ) ?
X        FTW_D : FTW_DNR);
X
X} /* GetType */
X
X
X/************************************************************************
X * S E T   F D   L I S T
X *
X * Given pointers to the current (head) and end + 1 of an array of
X * uninitialized struct filedata pointers, and a current (head) struct
X * datablock pointer, fill in the pointers in the array to point to the
X * filedata entries in the datablock chain.
X */
X
XPROC static SetFDList (fdpcurr, fdpend, dbcurr)
XREG    fdppt    fdpcurr;    /* start at head */
XREG    fdppt    fdpend;        /* last + 1     */
XREG    dbpt    dbcurr;        /* start at head */
X{
XREG    int    dbentry;    /* current index */
X
X    while (TRUE)                /* until return */
X    {
X        for (dbentry = 0; dbentry < DBENTRIES; dbentry++)    /* one block */
X        {
X        if (fdpcurr >= fdpend)        /* no more */
X            return;
X
X        *fdpcurr++ = (dbcurr -> fd) + dbentry;
X        }
X
X        dbcurr = dbcurr -> next;
X    }
X
X    /* never get here */
X
X} /* SetFDList */
X
X
X/************************************************************************
X * F D   C M P
X *
X * Given two pointers to pointers to filedata entries, compare the entries
X * and return -1, 0, or 1 for how they relate.  "Normal" files (FTW_F)
X * are always lower than other types, then names are compared with strcmp().
X */
X
XPROC static int FDCmp (fdpp1, fdpp2)
X    fdppt    fdpp1, fdpp2;
X{
XREG    int    type1 = (*fdpp1) -> type;
XREG    int    type2 = (*fdpp2) -> type;
X
X    return (((type1 == FTW_F) && (type2 != FTW_F)) ? -1 :
X        ((type1 != FTW_F) && (type2 == FTW_F)) ?  1 :
X        strcmp ((*fdpp1) -> name, (*fdpp2) -> name));
X
X} /* FDCmp */
X
X
X/************************************************************************
X * F R E E   B L O C K S
X *
X * Given pointers to heads of datablock and stringblock chains, free the
X * malloc'd memory in the chains.
X */
X
XPROC static FreeBlocks (dbhead, sbhead)
XREG    dbpt    dbhead;
XREG    sbpt    sbhead;
X{
XREG    dbpt    dbtemp;
XREG    sbpt    sbtemp;
X
X    while (dbhead != DBNULL)
X    {
X        dbtemp = dbhead -> next;
X        free ((char *) dbhead);
X        dbhead = dbtemp;
X    }
X
X    while (sbhead != SBNULL)
X    {
X        sbtemp = sbhead -> next;
X        free ((char *) sbhead);
X        sbhead = sbtemp;
X    }
X
X} /* FreeBlocks */
X
X
X#ifdef TEST
X
X/************************************************************************
X * TEST HARNESS:
X */
X
XPROC int fn (name, statp, type)
X    char    *name;
X    struct    stat *statp;
X    int    type;
X{
X    printf ("%-3s %06o \"%s\"\n",
X        (type == FTW_F)   ? "F"   : (type == FTW_D)  ? "D"  :
X        (type == FTW_DNR) ? "DNR" : (type == FTW_NS) ? "NS" : "?",
X        statp -> st_mode, name);
X
X    return (0);
X}
X
XPROC main()
X{
X    printf ("sftw returns %d\n", sftw (".", fn));
X}
X
X#endif TEST
@//E*O*F sftw.c//
if test 14313 -ne "`wc -c <'sftw.c'`"; then
    echo shar: error transmitting "'sftw.c'" '(should have been 14313 characters)'
fi
fi # end of overwriting check
echo shar: "End of shell archive."
exit 0